/**
 * 分组
 *
 * 题目描述
 * dd当上了宣传委员，开始组织迎新晚会，已知班里有
 * n个同学，每个同学有且仅有一个擅长的声部，把同学们分成恰好
 * m组，为了不搞砸节目，每一组里的同学都必须擅长同一个声部，当然，不同组同学擅长同一个声部的情况是可以出现的，
 * 毕竟一个声部也可以分成好几个part进行表演，但是他不希望出现任何一组的人过多，否则可能会导致场地分配不协调，也
 * 就是说，她希望人数最多的小组的人尽可能少，除此之外，对组内人员分配没有其他要求，她希望你告诉她，这个值是多少，
 * 如果无法顺利安排，请输出-1
 *
 * 输入描述:
 * 第一行两个数个数n,m(1≤m≤n≤100000)表示人数
 * 接下来一行n个数,a[i](1≤a[i]≤n)表示第i个学生的擅长声部
 *
 * 输出描述:
 * 输出一个数，表示人数最多的小组的人数
 */

import java.util.*;

/**
 * 这题我们常规的思路是将 每一组的人数一个一个枚举出来, 但是这样的话我们的时间复杂度会
 * 异常的大, 也不好去优化, 所以我们换个思路, 反过来, 我们枚举最大的每组人数.
 * 这里的枚举也可以使用二分查找来优化
 * 时间复杂度 : O(n)
 * 空间复杂度 : O(n)
 */

public class Main {

    // ***********************************************************************
    // 1. 直接对半分 最大的组, 这里会有一个问题, 比如分 6 的时候, 6 -> 2 2 2 和 1 2 3, 这样看要是只剩下两组的
    // 时候 3 3 是可以的, 但要是 还有 3 组, 就会出现问题, 明显 2 2 2 更加合适, 所以最大组合对半分就出现问题了
    public static void main1(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), m = in.nextInt();
        long[] nums = new long[n + 1];
        for (int i = 0; i < n; i++) {
            int x = in.nextInt();
            nums[x]++;
        }

        PriorityQueue<Long> queue = new PriorityQueue<>((a, b) -> Long.compare(b, a));
        for (int i = 0; i <= n; i++) {
            if (nums[i] != 0) {
                queue.add(nums[i]);
            }
        }

        if (queue.size() > m) {
            System.out.println(-1);
        } else {
            while (queue.size() < m) {
                long x = queue.poll();
                long k1 = x / 2;
                long k2 = x - k1;
                queue.add(k1);
                queue.add(k2);
            }
            System.out.println(queue.peek());
        }
    }

    static Map<Integer, Integer> hash;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int n = in.nextInt(), m = in.nextInt();

        hash = new HashMap<>();

        // 记录组中最大的人数
        int hmax = 0;

        for (int i = 0; i < n; i++) {
            int x = in.nextInt();
            hash.put(x, hash.getOrDefault(x, 0) + 1);
            hmax = Math.max(hmax, hash.get(x));
        }

        // 边界情况
        int kinds = hash.size();

        if(kinds > m) {

            System.out.println(-1);

        } else {

            // 暴⼒解法
//            for (int i = 1; i <= hmax; i++) {
//                if (check(i, m)) {
//                    System.out.println(i);
//                    break;
//                }
//            }

            // ⼆分解法
            int l = 1, r = hmax;
            while (l < r) {

                int mid = (l + r) / 2;

                if (check(mid, m)) {

                    r = mid;
                } else {

                    l = mid + 1;
                }
            }

            System.out.println(l);
        }
    }

    // 检查 每组最大的人数是 x, 是否可以成功分组
    public static boolean check(int x, int m) {

        // 组数
        int g = 0;

        for (int i : hash.values()) {

            // 这里记录每个数分的组数
            g += i / x + (i % x == 0 ? 0 : 1);
        }

        // 要是总的组数小于 m, 就可以成功的分组
        return g <= m;
    }
}